#include <iostream>
#include <stack>
#include <string>
#include <sstream>
#include <math.h> 
#include<bits/stdc++.h>
using namespace std;

// 定义两个栈
// 操作数栈
// 利用string对浮点数进行处理
stack<string> OPND;
// 运算符栈
stack<char> OPTR;

//判断是否是运算符
bool isOperator(char a)
{
    if (a == '+' || a == '-' || a == '*' || a == '/' || a == '(' || a == ')' || a == '=' || a == 'P' || a == 'N')
        return 1; //是运算符返回1
    else
        return 0; //不是运算符返回0
}
//判断是否是数字
bool isOperand(char a)
{
    if (a <= '9' && a >= '0')
        return 1;
    else
        return 0;
}
//判断是否是小数点
bool isDot(char a)
{
    if (a == '.')
        return 1;
    else
        return 0;
}
//判断优先级的函数
int isp(char a)
{
    switch (a)
    {
    case '=':
        return 0;
        break;
    case '(':
        return 1;
        break;
    case '+':
    case '-':
        return 2;
        break;
    case '*':
    case '/':
        return 3;
        break;
    case 'P':
    case 'N':
        return 4;
        break;
    case ')':
        return 5;
        break;
    default:
        return -1;
        break;
    }
}

//判断优先级的函数
int icp(char a)
{
    switch (a)
    {
    case '=':
        return 0;
        break;
    case ')':
        return 1;
        break;
    case '+':
    case '-':
        return 2;
        break;
    case '*':
    case '/':
        return 3;
        break;
    case 'P': //单目运算符的优先级为4
    case 'N':
        return 4;
        break;
    case '(':
        return 5;
        break;
    default:
        return -1;
        break;
    }
}
// 对表达式进行判断处理，筛选掉一部分的错误表达式
bool expressionProc(string str, string &res)
{
    int count = 0;
    bool flag = 0;
    // 记录小数点的个数
    for (int i = 0; i < str.length(); i++)
    {
        if (str.at(i) >= '0' && str.at(i) <= '9')
        {
            res = res + str.at(i);
        }
        else if (str.at(i) == '.')
        {
            res = res + str.at(i);
            count++;
        }
        else if (isOperator(str.at(i)))
        {

            res = res + str.at(i);
            flag = 1;  //有操作符
            count = 0; //遇到一个运算符号后，小数点的个数清零
        }
        if (count > 1)
        {
            return 0;
        }
    }
    if (res.length() == 0 || str.length() == 0 || res.at(res.length() - 1) != '=')
    {
        return 0;
    }
    return 1;
}
//计算表达式
double calculate(double x, char a, double y)
{
    switch (a)
    {
    case '+': //计算加法
        return x + y;
        break;
    case '-': //计算减法
        return x - y;
        break;
    case '*': //计算乘法
        return x * y;
        break;
    case '/': //计算除法,若除数为0，则提示错误
        if (abs(y - 0) <= 0.001)
        {
            cout << "Error. Can't divide 0! Please retry...";
        }
        return x / y;
        break;
    default:
        return -1;
        break;
    }
    return -1;
}
void doCalculate(string expression)
{
    //首先清空栈
    while (!OPND.empty())
    {
        OPND.pop();
    }
    while (!OPTR.empty())
    {
        OPTR.pop();
    }
    OPTR.push('='); //将=压栈
    double result, tempResult, OPND1, OPND2;
    int i, j;
    char a, b, c;
    a = expression.at(0);
    for (int k = 1; k < expression.length();)
    {
        while (a != '=' || OPTR.top() != '=')
        {
            if (!isOperator(a))
            {
                if (isOperand(a) || isDot(a))
                { // 操作数入栈
                    string temp;
                    temp.insert(0, 1, a);
                    OPND.push(temp);
                }
            }
            else if (isOperator(a))
            {
                b = OPTR.top();
                i = isp(b);
                j = icp(a);
                if (i < j)
                {
                    OPTR.push(a);
                }
                else
                {
                    b = OPTR.top();
                    OPTR.pop();
                    if (b != '(' && i == j || i > j)
                    {
                        c = OPTR.top();
                        if ((c == '(' || c == '=') && (b == 'P' || b == 'N')) //为单目运算符时
                        {
                            // 由于是以string类型入栈，因此需要做调整
                            // 判断是否有操作数
                            if (OPND.empty())
                            {
                                cout << "Error." << endl;
                                return;
                            }
                            string tempStr = OPND.top();
                            OPND.pop();
                            OPND1 = stod(tempStr);
                            switch (b)
                            {
                            case 'P': //即+（positive）
                                tempResult = OPND1 * 1;
                                break;
                            case 'N': //即-（negative）
                                tempResult = OPND1 * (-1);
                                break;
                            }
                        }
                        else //为双目运算符时
                        {
                            // 判断是否有右操作数
                            if (OPND.empty())
                            {
                                cout << "Error." << endl;
                                return;
                            }
                            string tempStr1 = OPND.top();
                            OPND.pop();
                            // 判断是否有左操作数
                            if (OPND.empty())
                            {
                                cout << "Error." << endl;
                                return;
                            }
                            OPND2 = stod(tempStr1);
                            string tempStr2 = OPND.top();
                            OPND.pop();
                            OPND1 = stod(tempStr2);
                            tempResult = calculate(OPND1, b, OPND2);
                        }
                        //将上面计算出的结果压入操作数栈
                        // 利用string对浮点数进行处理
                        OPND.push(std::to_string(tempResult));
                        continue;
                    }
                }
            }
            c = a;
            a = expression.at(k++);
            // 若表达式不止有1个数字
            while (!isOperator(a) && !isOperator(c) && (isOperand(a) || isDot(a)))
            {
                string tempString = OPND.top();
                OPND.pop();
                //追加字符
                tempString.insert(tempString.length(), 1, a);
                OPND.push(tempString);
                c = a;
                a = expression.at(k++);
            }
        }
    }
    result = stod(OPND.top());
    cout << result << endl;
}
int main()
{
    while (1)
    {
        // 用于存放原始表达式
        string expression;
        getline(cin, expression);
        if (expression == "end")
        {
            cout << "Closing..." << endl;
            break;
        }
        // 处理后的表达式
        string resExpression;
        // 对表达式进行处理
        bool c = expressionProc(expression, resExpression);
        if (c)
            doCalculate(resExpression);
        else
            cout << "Error." << endl;
    }
    return 0;
}
